/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.jsecode.lib.util;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
 * 字节码类型数据转换器, Please use ByteUtil
 * @author Administrator
 */
@Deprecated
public final class ByteConverts {



    /**
     * 将字节流作为十六进制数据输出，方便在日志中阅评
     * @param bArray
     * @return
     */
    public static String FormatOutputByte2Hex(byte[] bArray, int length) {
        StringBuilder sb = new StringBuilder();
        sb.append("\n");
        sb.append("00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F    TXT\n-------------------------------------------------------------------\n");
        byte[] t = new byte[16];
        for(int i = 0; i<= length /16; i++){
            if (i == length /16) {
                System.arraycopy(bArray, i * 16, t, 0, length - i * 16);
                for (int j = length - i * 16; j < 16; j++) {
                    t[j] = (byte) 0xFE;
                }
            }else {
                System.arraycopy(bArray, i * 16, t, 0, 16);
            }
            String hex = ByteConverts.bytesToHexString(t);
            StringBuilder sb1 = new StringBuilder();
            for (int x = 0; x< hex.length(); x +=2) {
                sb1.append(hex.substring(x, x +2)).append(" ");
            }
            sb.append(sb1.toString()).append("   ").append(replaceContorlchar(t)).append("\n");
        }
        return sb.toString();
    }

    /**
     * 将字节流作为十六进制数据在一行内输出，
     * @param bArray
     * @return
     */
    public static String FormatOutputByte2HexAll(byte[] bArray) {
    	StringBuilder sb = new StringBuilder();
        String hex = ByteConverts.bytesToHexString(bArray);    
        sb.append(hex.toString()).append("\n");
        return sb.toString();
    }
    // 将不可小视字符换成��？ 
    private static String replaceContorlchar(byte[] a) {
        for (int i = 0; i < a.length; i++) {
            if (a[i] < 0x20 || a[i] == 0x7F) {
                a[i] = (byte)0x3F;
            }
        }
        return new String(a);
    }
    public final static char[] BToA = "0123456789abcdef".toCharArray();

    private ByteConverts() {
    }

    /**
     * 十六进制字符串转换成字节数组
     * @param hex
     * @return
     */
    public static byte[] hexStringToByte(String hex) {
        int len = (hex.length() / 2);
        byte[] result = new byte[len];
        char[] achar = hex.toCharArray();
        for (int i = 0; i < len; i++) {
            int pos = i * 2;
            result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));
        }
        return result;
    }

    private static byte toByte(char c) {
        byte b = (byte) "0123456789ABCDEF".indexOf(c);
        return b;
    }

    /**
     * 把字节数组转换成16进制字符丄
     * @param bArray
     * @return
     */
    public static final String bytesToHexString(byte[] bArray) {
        StringBuffer sb = new StringBuffer(bArray.length);
        String sTemp;
        for (int i = 0; i < bArray.length; i++) {
            sTemp = Integer.toHexString(0xFF & bArray[i]);
            if (sTemp.length() < 2) {
                sb.append(0);
            }
            sb.append(sTemp.toUpperCase());
        }
        return sb.toString();
    }

    /**
     * 把字节数组转换为对象
     * @param bytes
     * @return
     * @throws IOException
     * @throws ClassNotFoundException
     */
    public static final Object bytesToObject(byte[] bytes) throws IOException, ClassNotFoundException {
        ByteArrayInputStream in = new ByteArrayInputStream(bytes);
        ObjectInputStream oi = new ObjectInputStream(in);
        Object o = oi.readObject();
        oi.close();
        return o;
    }

    /**
     * 把可序列化对象转换成字节数组
     * @param s
     * @return
     * @throws IOException
     */
    public static final byte[] objectToBytes(Serializable s) throws IOException {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        ObjectOutputStream ot = new ObjectOutputStream(out);
        ot.writeObject(s);
        ot.flush();
        ot.close();
        return out.toByteArray();
    }

    public static final String objectToHexString(Serializable s) throws IOException {
        return bytesToHexString(objectToBytes(s));
    }

    public static final Object hexStringToObject(String hex) throws IOException, ClassNotFoundException {
        return bytesToObject(hexStringToByte(hex));
    }

    /**
     * @函数功能: BCD码转丄进制丄(阿拉伯数捄)
     * @输入参数: BCD砄
     * @输出结果: 10进制丄
     */
    public static String bcd2Str(byte[] bytes) {
        StringBuffer temp = new StringBuffer(bytes.length * 2);

        for (int i = 0; i < bytes.length; i++) {
            temp.append((byte) ((bytes[i] & 0xf0) >>> 4));
            temp.append((byte) (bytes[i] & 0x0f));
        }
        return temp.toString().substring(0, 1).equalsIgnoreCase("0") ? temp.toString().substring(1) : temp.toString();
    }

    /**
	  * �����ƣ�00001000,00001111,00000001,00000000...
	  * ȡ����λת��ʮ�����
	  * ʮ����ƣ�8,F,1,0...
	  * ʮ�����ֵ�ȳ��ַ�Ȼ������ַ��ASCII
	  * ASCII:56,70,49,48
	  * @param c char
	  * @return string
	  */
	 public static String char2BitString(char c){
		 String res="";
		 int orgLen=0;
		 try{
			 String tmp=String.valueOf(c).toUpperCase();
			 char[] cs=tmp.toCharArray();
			 if(cs!=null && cs.length>=1){
				 int vc=charToInt(cs[0]);
				 res = Integer.toBinaryString(vc);
				 orgLen=res.length();
			 }
		 }catch(Exception ex){
			 ex.printStackTrace();
		 }
		 
		 for(int i=0;i<8-orgLen;i++){
			 res="0" + res;
		 }
		 return res;
	 }
	 
	 /**
	  * ת���ַ�ASCII
	  * @param c char
	  * @return int 
	  */
	 private static int charToInt(char c) {   
		 return  "0123456789ABCDEF".indexOf(c);   
	 }
    
    /**
     * @函数功能: 10进制串转为BCD砄
     * @输入参数: 10进制丄
     * @输出结果: BCD砄
     */
    public static byte[] str2Bcd(String asc) {
        int len = asc.length();
        int mod = len % 2;

        if (mod != 0) {
            asc = "0" + asc;
            len = asc.length();
        }

        byte abt[] = new byte[len];
        if (len >= 2) {
            len = len / 2;
        }

        byte bbt[] = new byte[len];
        abt = asc.getBytes();
        int j, k;

        for (int p = 0; p < asc.length() / 2; p++) {
            if ((abt[2 * p] >= '0') && (abt[2 * p] <= '9')) {
                j = abt[2 * p] - '0';
            } else if ((abt[2 * p] >= 'a') && (abt[2 * p] <= 'z')) {
                j = abt[2 * p] - 'a' + 0x0a;
            } else {
                j = abt[2 * p] - 'A' + 0x0a;
            }

            if ((abt[2 * p + 1] >= '0') && (abt[2 * p + 1] <= '9')) {
                k = abt[2 * p + 1] - '0';
            } else if ((abt[2 * p + 1] >= 'a') && (abt[2 * p + 1] <= 'z')) {
                k = abt[2 * p + 1] - 'a' + 0x0a;
            } else {
                k = abt[2 * p + 1] - 'A' + 0x0a;
            }

            int a = (j << 4) + k;
            byte b = (byte) a;
            bbt[p] = b;
        }
        return bbt;
    }

    public static String BCD2ASC(byte[] bytes) {
        StringBuffer temp = new StringBuffer(bytes.length * 2);

        for (int i = 0; i < bytes.length; i++) {
            int h = ((bytes[i] & 0xf0) >>> 4);
            int l = (bytes[i] & 0x0f);
            temp.append(BToA[h]).append(BToA[l]);
        }
        return temp.toString();
    }

    /**
     * 设置byte的index位（bit）的值为1
     * @param b
     * @param index
     * @return
     */
    public static byte setBitToByte(byte b, int index){
        b |= 0x1<<index;
        return b;
    }
    
    
    /**
     * 设置short的index位（bit）的值为1
     * @param b
     * @param index
     * @return
     */
    public static short setBitToShort(short b, int index){
        b |= 0x1<<index;
        return b;
    }
 

}
